﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace CommonClasses
{

  public  class class_NumberToString
    {
        string[,] SN = new string[10, 5];
        public string GetText(decimal Numb, string strCurrType)
        {
            //В качестве strCurrType задается один из вариантов: SOM, USD, EUR, RUR. Если другая валюта, тогда вернет в сомони
            switch (strCurrType)
            {
                case "SOM":
                    return NumbToStr(Numb, 1, "сомони", "сомони", "сомони", "дирам");
                //break;
                case "USD":
                    return NumbToStr(Numb, 1, "доллар", "доллара", "долларов", "цент");
                //break;
                case "EUR":
                    return NumbToStr(Numb, 1, "евро", "евро", "евро", "цент");
                //break;
                case "RUR":
                    return NumbToStr(Numb, 1, "рубль", "рубля", "рублей", "копеек");
                //break;
                default:
                    return NumbToStr(Numb, 1, "сомони", "сомони", "сомони", "дирам");
                //break;
            }
        }
        public string NumbToStr(decimal Numb, byte Cl, string strCurr1, string strCurr2, string strCurr3, string strCurr4)
        {
            //Declaring local variables
            SN[1, 1] = "один";
            SN[2, 1] = "два";
            SN[3, 1] = "три";
            SN[4, 1] = "четыре";
            SN[5, 1] = "пять";
            SN[6, 1] = "шесть";
            SN[7, 1] = "семь";
            SN[8, 1] = "восемь";
            SN[9, 1] = "девять";
            SN[1, 2] = "десять";
            SN[2, 2] = "двадцать";
            SN[3, 2] = "тридцать";
            SN[4, 2] = "сорок";
            SN[5, 2] = "пятьдесят";
            SN[6, 2] = "шестьдесят"; SN[7, 2] = "семьдесят"; SN[8, 2] = "восемьдесят"; SN[9, 2] = "девяносто";
            SN[1, 3] = "сто"; SN[2, 3] = "двести"; SN[3, 3] = "триста"; SN[4, 3] = "четыреста";
            SN[5, 3] = "пятьсот"; SN[6, 3] = "шестьсот"; SN[7, 3] = "семьсот"; SN[8, 3] = "восемьсот"; SN[9, 3] = "девятьсот";
            SN[1, 4] = "одиннадцать"; SN[2, 4] = "двенадцать"; SN[3, 4] = "тринадцать"; SN[4, 4] = "четырнадцать"; SN[5, 4] = "пятнадцать";
            SN[6, 4] = "шестнадцать"; SN[7, 4] = "семьнадцать"; SN[8, 4] = "восемьнадцать"; SN[9, 4] = "девятнадцать";

            string NTS, Tmp;
            byte St;
            int Triad;
            Int64 intDiram;

            intDiram = (Int64)(Numb * 100 - (Int64)(Numb) * 100);
            //intDiram = (Int64)Math.Round((decimal)intDiram / 10, 0);
            NTS = "";
            St = 1;
            while ((Int64)Numb > 0)
            {
                Triad = (int)((Int64)(Numb) - (Int64)(Numb * 0.001M) * 1000);
                Numb = Numb * 0.001M;             //отброс выделенной триады
                //System.Windows.Forms.MessageBox.Show(Triad.ToString() + "\t" + Numb.ToString());
                switch (St)
                {
                    case 1:   //единицы
                        NTS = TriadToStr(Triad, Cl);
                        if (Triad > 0) { NTS = NTS + " "; };
                        NTS = NTS + GetDeterm(Triad, strCurr1, strCurr2, strCurr3);
                        break;
                    case 2: //тысячи
                        Tmp = TriadToStr(Triad, 2);
                        if (Triad > 0) { Tmp = Tmp + " " + GetDeterm(Triad, "тысяча", "тысячи", "тысяч"); };
                        if (Tmp + NTS != "") { NTS = " " + NTS; };
                        NTS = Tmp + NTS;
                        break;
                    case 3: //миллионы
                        Tmp = TriadToStr(Triad, 1);
                        if (Triad > 0) { Tmp = Tmp + " " + GetDeterm(Triad, "миллион", "миллиона", "миллионов"); };
                        if (Tmp + NTS != "") { NTS = " " + NTS; };
                        NTS = Tmp + NTS;
                        break;
                    case 4: //миллиарды
                        Tmp = TriadToStr(Triad, 1);
                        if (Triad > 0) { Tmp = Tmp + " " + GetDeterm(Triad, "миллиард", "миллиарда", "миллиардов"); };
                        if (Tmp + NTS != "") { NTS = " " + NTS; };
                        NTS = Tmp + NTS;
                        break;
                    case 5: //миллиарды
                        Tmp = TriadToStr(Triad, 1);
                        if (Triad > 0) { Tmp = Tmp + " " + GetDeterm(Triad, "триллон", "триллиона", "триллионов"); };
                        if (Tmp + NTS != "") { NTS = " " + NTS; };
                        NTS = Tmp + NTS;
                        break;
                    default:    //неизвестные
                        NTS = "? " + NTS;
                        break;
                }
                St++;
            }
            return NTS + " " + intDiram + " " + strCurr4;
        }
        private string TriadToStr(int Triad, Byte Cl)
        {
            byte N1, N2, N3;
            string TTS;
            if (Triad == 0) { return ""; };      //выход при нулевой триаде
            //'----------------------------
            //' Выделение разрядов триады.
            //'----------------------------
            //System.Windows.Forms.MessageBox.Show(Triad.ToString());
            int temp;
            temp = Triad - (int)((decimal)Triad * 0.1M) * 10;
            N1 = (byte)temp;
            Triad = (int)(Triad * 0.1);
            N2 = (byte)(Triad - (Int64)((decimal)Triad * 0.1M) * 10);                //сотни
            N3 = (byte)(Triad * 0.1);    //тысячи
            //System.Windows.Forms.MessageBox.Show(N1.ToString() + "\n" + N2.ToString() + "\n" + N3.ToString());
            //'---------------------------------------
            //' Формирование текстовой записи триады.
            //'---------------------------------------
            TTS = "";     //текстовая запись триады
            if (N2 == 1)
            {
                //'--------------------------------------
                //' Обработка разрядов десятков и единиц
                //' для 9 < N2*10+N1 < 20.
                //'--------------------------------------
                if (N1 == 0) { TTS = SN[1, 2]; } else { TTS = SN[N1, 4]; };
            }
            else
            {
                //'---------------------------
                //' Обработка разряда единиц.
                //'---------------------------
                if (N1 > 0)
                {
                    if (N1 == 1)
                    {
                        switch (Cl)
                        {
                            case 0:
                                TTS = "одно";
                                break;
                            case 1:
                                TTS = SN[N1, 1];
                                break;
                            case 2:
                                TTS = "одна";
                                break;
                        }
                    }
                    else if (N1 == 2)
                    {
                        switch (Cl)
                        {
                            case 0:
                                TTS = SN[N1, 1];
                                break;
                            case 1:
                                TTS = SN[N1, 1];
                                break;
                            case 2:
                                TTS = "две";
                                break;
                        }
                    }
                    else
                    {
                        TTS = SN[N1, 1];
                    }
                }
                //'-----------------------------
                //' Обработка разряда десятков.
                //'-----------------------------
                if (N2 > 0)
                {
                    if (N1 > 0) { TTS = " " + TTS; };
                    TTS = SN[N2, 2] + TTS;
                }
            }
            //'--------------------------
            //' Обработка разряда сотен.
            //'--------------------------
            if (N3 > 0)
            {
                if (N1 > 0 || N2 > 0) { TTS = " " + TTS; };
                TTS = SN[N3, 3] + TTS;
            }
            return TTS;
        }
        private string GetDeterm(int Triad, string Item1, string Item2, string Item3)
        {
            byte N1, N2;
            N1 = (byte)(Triad - (int)(Triad / 10) * 10);
            Triad = (int)(Triad * 0.1);
            N2 = (byte)(Triad / 10);
            if (N2 != 1)
            {
                switch (N1)
                {
                    case 1:
                        return Item1;
                    case 2:
                        return Item2;
                    case 3:
                        return Item2;
                    case 4:
                        return Item2;
                    default:
                        return Item3;
                }
            }
            else
            {
                return Item3;
            }
        }
    }

}
